;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-USER; Base: 10 -*-
;;; Regex test case perl-evita.retest from Perl.
;;;
;;; This file is automatically generated from Perl's test data with
;;; Perl 5.008004 at 2004-05-24 03:17:05 UTC.
;;;
;;; See: http://www.perl.com/ for Perl.
;;;
;

;;;; perl-evita.retest/2: a)
;;;
;;;    Syntax error. (c)
;
(test-case    ; Unmatched close-parenthesis
  "perl-evita/2"
  "a)"
  "a)"
  '(:single-line nil)
  :compile   ; Unmatched )
 )

;;;; perl-evita.retest/3: a]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/3"
  "a]"
  "a]"
  '(:single-line nil)
  (list "a]") )

;;;; perl-evita.retest/4: a}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/4"
  "a}"
  "a}"
  '(:single-line nil)
  (list "a}") )

;;;; perl-evita.retest/5: |foo
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/5"
  "|foo"
  "foo"
  '(:single-line nil)
  (list "") )

;;;; perl-evita.retest/6: foo|
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/6"
  "foo|"
  "foo"
  '(:single-line nil)
  (list "foo") )

;;;; perl-evita.retest/7: .*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/7"
  ".*"
  ""
  '(:single-line nil)
  (list "") )

;;;; perl-evita.retest/8: x
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/8"
  "x"
  "x"
  '(:single-line nil)
  (list "x") )

;;;; perl-evita.retest/9: xyz
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/9"
  "xyz"
  "xyz"
  '(:single-line nil)
  (list "xyz") )

;;;; perl-evita.retest/10: xyz
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/10"
  "xyz"
  "<xyz>"
  '(:single-line nil)
  (list "xyz") )

;;;; perl-evita.retest/11: [-]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/11"
  "[-]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; perl-evita.retest/12: []]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/12"
  "[]]"
  "]"
  '(:single-line nil)
  (list "]") )

;;;; perl-evita.retest/13: []
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/13"
  "[]"
  "-"
  '(:single-line nil)
  :compile   ; Unmatched [
 )

;;;; perl-evita.retest/14: [a-c]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/14"
  "[a-c]"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; perl-evita.retest/15: [a\-c]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-evita/15"
  "[a\\-c]"
  "b"
  '(:single-line nil)
  nil )

;;;; perl-evita.retest/16: [a\]c]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/16"
  "[a\\]c]"
  "]"
  '(:single-line nil)
  (list "]") )

;;;; perl-evita.retest/17: a|b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/17"
  "a|b"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-evita.retest/18: a|b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/18"
  "a|b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; perl-evita.retest/19: x{}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/19"
  "x{}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/20: x{a}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/20"
  "x{a}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/21: x{,}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/21"
  "x{,}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/22: x{1,a}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/22"
  "x{1,a}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/23: x{3}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/23"
  "x{3}"
  "axxxxxb"
  '(:single-line nil)
  (list "xxx") )

;;;; perl-evita.retest/24: x{3,}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/24"
  "x{3,}"
  "axxxxxb"
  '(:single-line nil)
  (list "xxxxx") )

;;;; perl-evita.retest/25: x{3,4}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/25"
  "x{3,4}"
  "axxxxxb"
  '(:single-line nil)
  (list "xxxx") )

;;;; perl-evita.retest/26: x{}?
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/26"
  "x{}?"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/27: x{3}?
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/27"
  "x{3}?"
  "axxxxxb"
  '(:single-line nil)
  (list "xxx") )

;;;; perl-evita.retest/28: x{3,}?
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/28"
  "x{3,}?"
  "axxxxxb"
  '(:single-line nil)
  (list "xxx") )

;;;; perl-evita.retest/29: x{3,4}?
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/29"
  "x{3,4}?"
  "axxxxxb"
  '(:single-line nil)
  (list "xxx") )

;;;; perl-evita.retest/30: [^ab]*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/30"
  "[^ab]*"
  "cde"
  '(:single-line nil)
  (list "cde") )

;;;; perl-evita.retest/31: (x){}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/31"
  "(x){}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/32: (x){a}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/32"
  "(x){a}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/33: (x){,}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/33"
  "(x){,}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/34: (x){1,a}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/34"
  "(x){1,a}"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/35: (x){3}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/35"
  "(x){3}"
  "axxxxxb"
  '(:single-line nil)
  (list
    "xxx"
    "x" ) )

;;;; perl-evita.retest/36: (x){3,}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/36"
  "(x){3,}"
  "axxxxxb"
  '(:single-line nil)
  (list
    "xxxxx"
    "x" ) )

;;;; perl-evita.retest/37: (x){3,4}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/37"
  "(x){3,4}"
  "axxxxxb"
  '(:single-line nil)
  (list
    "xxxx"
    "x" ) )

;;;; perl-evita.retest/38: (x){}?
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-evita/38"
  "(x){}?"
  "axxxxxb"
  '(:single-line nil)
  :compile   ; But Perl accepts this.
 )

;;;; perl-evita.retest/39: (x){3}?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/39"
  "(x){3}?"
  "axxxxxb"
  '(:single-line nil)
  (list
    "xxx"
    "x" ) )

;;;; perl-evita.retest/40: (x){3,}?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/40"
  "(x){3,}?"
  "axxxxxb"
  '(:single-line nil)
  (list
    "xxx"
    "x" ) )

;;;; perl-evita.retest/41: (x){3,4}?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/41"
  "(x){3,4}?"
  "axxxxxb"
  '(:single-line nil)
  (list
    "xxx"
    "x" ) )

;;;; perl-evita.retest/42: a*?x
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/42"
  "a*?x"
  "aaax"
  '(:single-line nil)
  (list "aaax") )

;;;; perl-evita.retest/43: `(.*)`
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/43"
  "`(.*)`"
  "The `foo` is `bar`"
  '(:single-line nil)
  (list
    "`foo` is `bar`"
    "foo` is `bar" ) )

;;;; perl-evita.retest/44: `(.*)*`
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/44"
  "`(.*)*`"
  "The `foo` is `bar`"
  '(:single-line nil)
  (list
    "`foo` is `bar`"
    "" ) )

;;;; perl-evita.retest/45: \bfoo\b(.*)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/45"
  "\\bfoo\\b(.*)"
  "foobar foo baz"
  '(:single-line nil)
  (list
    "foo baz"
    " baz" ) )

;;;; perl-evita.retest/46: foo(?=bar)(.*)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/46"
  "foo(?=bar)(.*)"
  "foo foobar baz"
  '(:single-line nil)
  (list
    "foobar baz"
    "bar baz" ) )

;;;; perl-evita.retest/47: foo(?!bar)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/47"
  "foo(?!bar)"
  "foobaz foobar baz"
  '(:single-line nil)
  (list "foo") )

;;;; perl-evita.retest/48: \d+(?!\.)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/48"
  "\\d+(?!\\.)"
  "OH 44272"
  '(:single-line nil)
  (list "44272") )

;;;; perl-evita.retest/49: \d+(?=[^.])
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/49"
  "\\d+(?=[^.])"
  "OH 44272"
  '(:single-line nil)
  (list "4427") )

;;;; perl-evita.retest/50: ..XY
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/50"
  "..XY"
  "abXY"
  '(:single-line nil)
  (list "abXY") )

;;;; perl-evita.retest/51: (..)XY
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/51"
  "(..)XY"
  "abXY"
  '(:single-line nil)
  (list
    "abXY"
    "ab" ) )

;;;; perl-evita.retest/52: ((..)XY)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-evita/52"
  "((..)XY)"
  "abXY"
  '(:single-line nil)
  (list
    "abXY"
    "abXY"
    "ab" ) )

;;;; perl-evita.retest/53: ..XY
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/53"
  "..XY"
  "xxabXY"
  '(:single-line nil)
  (list "abXY") )

;;;; perl-evita.retest/54: (..)XY
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/54"
  "(..)XY"
  "xxabXY"
  '(:single-line nil)
  (list
    "abXY"
    "ab" ) )

;;;; perl-evita.retest/55: ((..)XY)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-evita/55"
  "((..)XY)"
  "xxabXY"
  '(:single-line nil)
  (list
    "abXY"
    "abXY"
    "ab" ) )

;;;; perl-evita.retest/56: .*A.
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/56"
  ".*A."
  "aAa"
  '(:single-line nil)
  (list "aAa") )

;;;; perl-evita.retest/57: <B[^>]*>.*</B>
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/57"
  "<B[^>]*>.*</B>"
  "FOO<B></B>BAR"
  '(:single-line nil)
  (list "<B></B>") )

;;;; perl-evita.retest/58: ([^:]+):(/?.*/)([^/]+)
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/58"
  "([^:]+):(/?.*/)([^/]+)"
  "www:/home.htm"
  '(:single-line nil)
  (list
    "www:/home.htm"
    "www"
    "/"
    "home.htm" ) )

;;;; perl-evita.retest/59: ([^:]+):(/?.*/)([^/]+)
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/59"
  "([^:]+):(/?.*/)([^/]+)"
  "www:/runonce/default.asp"
  '(:single-line nil)
  (list
    "www:/runonce/default.asp"
    "www"
    "/runonce/"
    "default.asp" ) )

;;;; perl-evita.retest/60: http://([^.]+)\.jp\.msn\.com(/.*)?
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-evita/60"
  "http://([^.]+)\\.jp\\.msn\\.com(/.*)?"
  "http://www.jp.msn.com/foo.htm"
  '(:single-line nil)
  (list
    "http://www.jp.msn.com/foo.htm"
    "www"
    "/foo.htm" ) )

;;;; perl-evita.retest/61: http://([^.]+)\.jp\.msn\.com(/.*)?
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-evita/61"
  "http://([^.]+)\\.jp\\.msn\\.com(/.*)?"
  "http://www.jp.msn.com/"
  '(:single-line nil)
  (list
    "http://www.jp.msn.com/"
    "www"
    "/" ) )

;;;; perl-evita.retest/62: http://([^.]+)\.jp\.msn\.com(/.*)?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/62"
  "http://([^.]+)\\.jp\\.msn\\.com(/.*)?"
  "http://www.jp.msn.com"
  '(:single-line nil)
  (list
    "http://www.jp.msn.com"
    "www" ) )

;;;; perl-evita.retest/63: \S+\s+\S+
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/63"
  "\\S+\\s+\\S+"
  "19990310   15438"
  '(:single-line nil)
  (list "19990310   15438") )

;;;; perl-evita.retest/64: (?:(a)|(b)|(c))+
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/64"
  "(?:(a)|(b)|(c))+"
  "abca"
  '(:single-line nil)
  (list
    "abca"
    "a"
    "b"
    "c" ) )

;;;; perl-evita.retest/65: (?:(a)|(b)|(c))+
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/65"
  "(?:(a)|(b)|(c))+"
  "abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; perl-evita.retest/66: (?:(a)|(b)|(c))+
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/66"
  "(?:(a)|(b)|(c))+"
  "abcc"
  '(:single-line nil)
  (list
    "abcc"
    "a"
    "b"
    "c" ) )

;;;; perl-evita.retest/67: (?:(a)(b))*x()
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/67"
  "(?:(a)(b))*x()"
  "ababb x"
  '(:single-line nil)
  (list
    "x"
    nil
    nil
    "" ) )

;;;; perl-evita.retest/68: (foo|bar|x\1)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/68"
  "(foo|bar|x\\1)*"
  "fooxfoo"
  '(:single-line nil)
  (list
    "fooxfoo"
    "xfoo" ) )

;;;; perl-evita.retest/69: (foo|bar|x\1)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/69"
  "(foo|bar|x\\1)*"
  "barxbar"
  '(:single-line nil)
  (list
    "barxbar"
    "xbar" ) )

;;;; perl-evita.retest/70: (foo|bar|x\1)*
;;;
;;;    Matched. (y)
;
(test-case    ; match empty
  "perl-evita/70"
  "(foo|bar|x\\1)*"
  "x"
  '(:single-line nil)
  (list "") )

;;;; perl-evita.retest/71: (foo|bar|x\1)+
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-evita/71"
  "(foo|bar|x\\1)+"
  "x"
  '(:single-line nil)
  nil )

;;;; perl-evita.retest/72: ((a{0,5})*)*[c]
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-evita/72"
  "((a{0,5})*)*[c]"
  "ac"
  '(:single-line nil)
  (list
    "ac"
    ""
    "" ) )

;;;; perl-evita.retest/73: (){0}()
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-evita/73"
  "(){0}()"
  "x"
  '(:single-line nil)
  (list
    ""
    nil
    "" ) )

;;;; perl-evita.retest/74: ((){0}.)+()
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-evita/74"
  "((){0}.)+()"
  "x"
  '(:single-line nil)
  (list
    "x"
    "x"
    nil
    "" ) )

;;;; perl-evita.retest/75: \Q*foo*\E
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/75"
  "\\Q*foo*\\E"
  "foo *foo*"
  '(:single-line nil)
  (list "*foo*") )



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; #####################################################################
;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 
;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; stringfy
;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; c = char        s = string
;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; C = char/i      S = string/i
;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 
;;;


;;;; perl-evita.retest/85: [a]b
;;;
;;;    Matched. (y)
;
(test-case    ; c+c
  "perl-evita/85"
  "[a]b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; perl-evita.retest/86: [a]bcd
;;;
;;;    Matched. (y)
;
(test-case    ; c+s
  "perl-evita/86"
  "[a]bcd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; perl-evita.retest/87: [a]bcd[e]
;;;
;;;    Matched. (y)
;
(test-case    ; c+s+c
  "perl-evita/87"
  "[a]bcd[e]"
  "abcde"
  '(:single-line nil)
  (list "abcde") )

;;;; perl-evita.retest/88: [a]bcd[e][f]
;;;
;;;    Matched. (y)
;
(test-case    ; c+s+c+c
  "perl-evita/88"
  "[a]bcd[e][f]"
  "abcdef"
  '(:single-line nil)
  (list "abcdef") )


;;;; perl-evita.retest/90: ab[c]
;;;
;;;    Matched. (y)
;
(test-case    ; s+c
  "perl-evita/90"
  "ab[c]"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-evita.retest/91: ab(?:cd)
;;;
;;;    Matched. (y)
;
(test-case    ; s+s
  "perl-evita/91"
  "ab(?:cd)"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; perl-evita.retest/92: ab[c]de
;;;
;;;    Matched. (y)
;
(test-case    ; s+c+s
  "perl-evita/92"
  "ab[c]de"
  "abcde"
  '(:single-line nil)
  (list "abcde") )

;;;; perl-evita.retest/93: ab(?i:cd)
;;;
;;;    Matched. (y)
;
(test-case    ; s+S
  "perl-evita/93"
  "ab(?i:cd)"
  "abCD"
  '(:single-line nil)
  (list "abCD") )

;;;; perl-evita.retest/94: ab(?i:12)
;;;
;;;    Matched. (y)
;
(test-case    ; s+s
  "perl-evita/94"
  "ab(?i:12)"
  "ab12"
  '(:single-line nil)
  (list "ab12") )


;;;; perl-evita.retest/96: (?i)[a]b
;;;
;;;    Matched. (y)
;
(test-case    ; C+C
  "perl-evita/96"
  "(?i)[a]b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; perl-evita.retest/97: (?i)[a]bcd
;;;
;;;    Matched. (y)
;
(test-case    ; C+S
  "perl-evita/97"
  "(?i)[a]bcd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; perl-evita.retest/98: (?i)[a]bcd[e]
;;;
;;;    Matched. (y)
;
(test-case    ; C+S+C
  "perl-evita/98"
  "(?i)[a]bcd[e]"
  "abcde"
  '(:single-line nil)
  (list "abcde") )

;;;; perl-evita.retest/99: (?i)[a]bcd[e][f]
;;;
;;;    Matched. (y)
;
(test-case    ; C+S+C+C
  "perl-evita/99"
  "(?i)[a]bcd[e][f]"
  "abcdef"
  '(:single-line nil)
  (list "abcdef") )


;;;; perl-evita.retest/101: (?i)[a]1
;;;
;;;    Matched. (y)
;
(test-case    ; C+c
  "perl-evita/101"
  "(?i)[a]1"
  "a1"
  '(:single-line nil)
  (list "a1") )

;;;; perl-evita.retest/102: (?i)[a]123
;;;
;;;    Matched. (y)
;
(test-case    ; C+s
  "perl-evita/102"
  "(?i)[a]123"
  "a123"
  '(:single-line nil)
  (list "a123") )

;;;; perl-evita.retest/103: (?i)[a]123[e]
;;;
;;;    Matched. (y)
;
(test-case    ; C+s+C
  "perl-evita/103"
  "(?i)[a]123[e]"
  "a123e"
  '(:single-line nil)
  (list "a123e") )

;;;; perl-evita.retest/104: (?i)[a]123[e][f]
;;;
;;;    Matched. (y)
;
(test-case    ; C+s+C+C
  "perl-evita/104"
  "(?i)[a]123[e][f]"
  "a123ef"
  '(:single-line nil)
  (list "a123ef") )

;;;; perl-evita.retest/105: (?i)[a]123[e][f]4
;;;
;;;    Matched. (y)
;
(test-case    ; C+s+C+C+c
  "perl-evita/105"
  "(?i)[a]123[e][f]4"
  "a123ef4"
  '(:single-line nil)
  (list "a123ef4") )


;;;; perl-evita.retest/107: (?i)[a][*]b
;;;
;;;    Matched. (y)
;
(test-case    ; C+c+c
  "perl-evita/107"
  "(?i)[a][*]b"
  "a*b"
  '(:single-line nil)
  (list "a*b") )

;;;; perl-evita.retest/108: (?i)[a][*]bcd
;;;
;;;    Matched. (y)
;
(test-case    ; C+c+s
  "perl-evita/108"
  "(?i)[a][*]bcd"
  "a*bcd"
  '(:single-line nil)
  (list "a*bcd") )

;;;; perl-evita.retest/109: (?i)[a][*]bcd[e]
;;;
;;;    Matched. (y)
;
(test-case    ; C+c+S+C
  "perl-evita/109"
  "(?i)[a][*]bcd[e]"
  "a*bcde"
  '(:single-line nil)
  (list "a*bcde") )

;;;; perl-evita.retest/110: (?i)[a][*]bcd[e][f]
;;;
;;;    Matched. (y)
;
(test-case    ; C+c+S+C
  "perl-evita/110"
  "(?i)[a][*]bcd[e][f]"
  "a*bcdef"
  '(:single-line nil)
  (list "a*bcdef") )

;;;; perl-evita.retest/111: (?i)[a][*]bcd[e]4
;;;
;;;    Matched. (y)
;
(test-case    ; C+c+S+c
  "perl-evita/111"
  "(?i)[a][*]bcd[e]4"
  "a*bcde4"
  '(:single-line nil)
  (list "a*bcde4") )


;;;; perl-evita.retest/113: (?i)ab[c]
;;;
;;;    Matched. (y)
;
(test-case    ; S+C
  "perl-evita/113"
  "(?i)ab[c]"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-evita.retest/114: (?i)ab(?:cd)
;;;
;;;    Matched. (y)
;
(test-case    ; S+S
  "perl-evita/114"
  "(?i)ab(?:cd)"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; perl-evita.retest/115: (?i)ab[c]de
;;;
;;;    Matched. (y)
;
(test-case    ; S+C+S
  "perl-evita/115"
  "(?i)ab[c]de"
  "abcde"
  '(:single-line nil)
  (list "abcde") )

;;;; perl-evita.retest/116: (?i)ab(?i:cd)
;;;
;;;    Matched. (y)
;
(test-case    ; S+S
  "perl-evita/116"
  "(?i)ab(?i:cd)"
  "abCD"
  '(:single-line nil)
  (list "abCD") )

;;;; perl-evita.retest/117: (?i)ab(?:12)
;;;
;;;    Matched. (y)
;
(test-case    ; S+s
  "perl-evita/117"
  "(?i)ab(?:12)"
  "ab12"
  '(:single-line nil)
  (list "ab12") )


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Lookbehind with arbitrary regex
;;;

;;;; perl-evita.retest/120: (?<=(A |The |Mr[.]))Foo
;;;
;;;    Matched. (y)
;
(test-case
  "perl-evita/120"
  "(?<=(A |The |Mr[.]))Foo"
  "Foo, A Foo, Mr.Foo"
  '(:single-line nil)
  (list ".Foo") )

;;;; perl-evita.retest/121: a(.{3,}?)b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/121"
  "a(.{3,}?)b"
  "aHxyb"
  '(:single-line nil)
  (list
    "aHxyb"
    "Hxy" ) )

;;;; perl-evita.retest/122: ^(b+?|a){1,2}?c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/122"
  "^(b+?|a){1,2}?c"
  "bbbc"
  '(:single-line nil)
  (list
    "bbbc"
    "bb" ) )

;;;; perl-evita.retest/123: ^(b+?|a){1,2}?c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-evita/123"
  "^(b+?|a){1,2}?c"
  "abbbbbbbbbbbc"
  '(:single-line nil)
  (list
    "abbbbbbbbbbbc"
    "bbbbbbbbbbb" ) )

; EOF
